package estore.estore.service;

import estore.estore.model.Product;
import java.util.*;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * 商品服务类，负责商品相关的业务逻辑
 * 包含数据持久化、配置管理和备份功能
 */
public class ProductService {

    // 使用Map存储商品数据，key是商品ID，value是商品对象
    private Map<String, Product> productData = new HashMap<>();
    private String dataFilePath;
    private String backupFilePath;

    /**
     * 构造函数，初始化配置和数据加载
     */
    public ProductService() {
        // 先加载配置
        loadConfig();
        // 再加载数据（会覆盖初始化的测试数据）
        loadData();
    }

    /**
     * 加载配置文件
     */
    private void loadConfig() {
        Properties props = new Properties();
        File configFile = new File("config.properties");

        if (!configFile.exists()) {
            // 如果配置文件不存在，创建默认配置
            createDefaultConfig();
            System.out.println("配置文件不存在，已创建默认配置");
        }

        try (InputStreamReader reader = new InputStreamReader(
                new FileInputStream("config.properties"), "UTF-8")) {
            props.load(reader);
            dataFilePath = props.getProperty("data.file.path", "products.dat");
            backupFilePath = props.getProperty("backup.file.path", "products.dat.bak");
            System.out.println("配置文件加载成功: data.file.path=" + dataFilePath);
        } catch (IOException e) {
            System.out.println("加载配置文件失败: " + e.getMessage());
            // 使用默认值
            dataFilePath = "products.dat";
            backupFilePath = "products.dat.bak";
        }
    }

    /**
     * 创建默认配置文件
     */
    private void createDefaultConfig() {
        try (OutputStreamWriter writer = new OutputStreamWriter(
                new FileOutputStream("config.properties"), "UTF-8")) {
            Properties props = new Properties();
            props.setProperty("data.file.path", "products.dat");
            props.setProperty("backup.file.path", "products.dat.bak");
            props.store(writer, "EStore Configuration");
        } catch (IOException e) {
            System.out.println("创建配置文件失败: " + e.getMessage());
        }
    }

    /**
     * 保存数据到文件
     */
    public void saveData() {
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(dataFilePath))) {
            oos.writeObject(productData);
            System.out.println("商品数据已保存到文件: " + dataFilePath);
        } catch (IOException e) {
            System.out.println("保存数据失败: " + e.getMessage());
        }
    }

    /**
     * 从文件加载数据
     */
    @SuppressWarnings("unchecked")
    public void loadData() {
        File file = new File(dataFilePath);
        if (!file.exists()) {
            System.out.println("数据文件不存在，使用初始测试数据");
            // 初始化测试数据
            initializeTestData();
            // 保存初始数据到文件
            saveData();
            return;
        }

        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream(dataFilePath))) {
            productData = (Map<String, Product>) ois.readObject();
            System.out.println("商品数据已从文件加载，共 " + productData.size() + " 个商品");
        } catch (IOException | ClassNotFoundException e) {
            System.out.println("加载数据失败: " + e.getMessage() + "，使用初始测试数据");
            // 加载失败时使用测试数据
            initializeTestData();
        }
    }

    /**
     * 初始化测试数据
     */
    private void initializeTestData() {
        productData.clear();
        productData.put("p001", new Product("p001", "Java从入门到精通", 99.0, 100));
        productData.put("p002", new Product("p002", "高性能MySQL", 128.5, 50));
        productData.put("p003", new Product("p003", "颈椎康复指南", 45.0, 200));
        productData.put("p004", new Product("p004", "生发秘籍", 88.0, 0));
        productData.put("p005", new Product("p005", "Python编程", 79.0, 80));
        productData.put("p006", new Product("p006", "数据结构与算法", 150.0, 30));
    }

    /**
     * 备份数据文件
     */
    public void backupData() {
        System.out.println("开始备份数据...");

        File sourceFile = new File(dataFilePath);
        if (!sourceFile.exists()) {
            System.out.println("备份失败: 源数据文件不存在");
            return;
        }

        try (FileInputStream fis = new FileInputStream(dataFilePath);
             FileOutputStream fos = new FileOutputStream(backupFilePath)) {

            byte[] buffer = new byte[1024]; // 1KB缓冲区
            int bytesRead;
            long totalBytes = 0;

            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
                totalBytes += bytesRead;
            }

            System.out.println("数据备份完成: " + backupFilePath + " (" + totalBytes + " 字节)");

        } catch (FileNotFoundException e) {
            System.out.println("备份失败: 文件不存在 - " + e.getMessage());
        } catch (IOException e) {
            System.out.println("备份失败: " + e.getMessage());
        }
    }

    /**
     * 获取所有商品列表
     * @return 商品列表
     */
    public List<Product> getAllProducts() {
        return new ArrayList<>(productData.values());
    }

    /**
     * 根据ID查找商品
     * @param id 商品ID
     * @return 找到的商品对象，如果不存在则返回null
     */
    public Product findProductById(String id) {
        return productData.get(id);
    }

    /**
     * 更新商品库存（购物车购买时调用）
     */
    public boolean updateProductStock(String productId, int quantity) {
        Product product = productData.get(productId);
        if (product != null && product.getStock() >= quantity) {
            product.setStock(product.getStock() - quantity);
            saveData(); // 更新后自动保存
            return true;
        }
        return false;
    }

    /**
     * 添加商品（管理员功能）
     */
    public boolean addProduct(Product product) {
        if (productData.containsKey(product.getId())) {
            return false; // 商品ID已存在
        }
        productData.put(product.getId(), product);
        saveData(); // 添加后自动保存
        return true;
    }

    /**
     * 删除商品（管理员功能）
     */
    public boolean deleteProduct(String id) {
        Product removed = productData.remove(id);
        if (removed != null) {
            saveData(); // 删除后自动保存
            return true;
        }
        return false;
    }

    // 获取文件路径的方法，供外部调用
    public String getDataFilePath() {
        return dataFilePath;
    }

    public String getBackupFilePath() {
        return backupFilePath;
    }
}